package com.ruoyi.common.utils;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;
import java.util.stream.Collectors;

public class JsonUtils {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * JSON 字符串转 Java 对象
     * @param json JSON 字符串
     * @param clazz 目标类
     * @param <T> 泛型类型
     * @return Java 对象
     */
    public static <T> T parseObject(String json, Class<T> clazz) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        try {
            return objectMapper.readValue(json, clazz);
        } catch (Exception e) {
            throw new RuntimeException("JSON 转换失败", e);
        }
    }

    /**
     * 处理复杂类型（如 List、Map）
     * @param json JSON 字符串
     * @param typeReference 类型引用（如 new TypeReference<List<User>>() {}）
     * @param <T> 泛型类型
     * @return Java 对象
     */
    public static <T> T parseObject(String json, TypeReference<T> typeReference) {
        if (json == null || json.isEmpty()) {
            return null;
        }
        try {
            return objectMapper.readValue(json, typeReference);
        } catch (Exception e) {
            throw new RuntimeException("JSON 转换失败", e);
        }
    }
    /**
     * 将 List<JSONObject> 转换为 List<T>（去除所有空格和换行）
     * @param jsonObjects JSON 对象列表
     * @param clazz 目标类
     * @param <T> 泛型类型
     * @return 转换后的对象列表
     */
    public static <T> List<T> convert(List<JSONObject> jsonObjects, Class<T> clazz) {
        return jsonObjects.stream()
                .map(json -> {
                    // 完全去除所有空白字符（包括空格、换行、制表符等）
                    String compactJson = removeAllWhitespace(json.toJSONString());
                    return JSON.parseObject(compactJson, clazz);
                })
                .collect(Collectors.toList());
    }

    /**
     * 将单个 JSONObject 转换为对象（去除所有空格和换行）
     * @param jsonObject JSON 对象
     * @param clazz 目标类
     * @param <T> 泛型类型
     * @return 转换后的对象
     */
    public static <T> T convert(JSONObject jsonObject, Class<T> clazz) {
        String compactJson = removeAllWhitespace(jsonObject.toJSONString());
        return JSON.parseObject(compactJson, clazz);
    }

    /**
     * 移除字符串中所有空白字符（包括空格、换行、制表符等）
     * @param input 输入字符串
     * @return 无空白字符的字符串
     */
    private static String removeAllWhitespace(String input) {
        // 处理所有空白字符和转义序列
        return input.replace("\\n", "")
                .replace("\\r", "")
                .replace("\\t", "")
                .replace("\n", "")
                .replace("\r", "")
                .replace("\t", "")
                .replace(" ", "");
    }

}
